// 使用ES模块导入方式
import { app, BrowserWindow, ipcMain } from 'electron';
import * as path from 'path';
import * as fs from 'fs';
import { SerialPort } from 'serialport';
import { ReadlineParser } from '@serialport/parser-readline';

// 存储串口实例
let port: any = null;
let parser: any = null;

// 存储串口数据回调
// 暂时保留回调机制，以备后续功能扩展

// 添加调试日志
console.log('Electron主进程启动中...');
console.log('当前目录:', __dirname);

// 确保应用只运行一个实例
const gotTheLock = app.requestSingleInstanceLock();

if (!gotTheLock) {
  app.quit();
} else {
  app.on('second-instance', () => {
    // 当用户尝试打开第二个实例时，聚焦到现有的窗口
    if (global.mainWindow) {
      if (global.mainWindow.isMinimized()) global.mainWindow.restore();
      global.mainWindow.focus();
    }
  });
}

// 声明mainWindow变量
declare global {
  var mainWindow: import('electron').BrowserWindow | null;
}

global.mainWindow = null;

// 创建浏览器窗口的函数
function createWindow() {
  // 使用内联的preload脚本，而不是外部文件
  console.log('使用内联preload脚本...');
  
  // 创建主窗口
  global.mainWindow = new BrowserWindow({
    width: 800,
    height: 600,
    minWidth: 800,
    minHeight: 600,
    webPreferences: {
      preload: path.join(__dirname, 'preload.js'),
      nodeIntegration: false,
      contextIsolation: true,
      devTools: true, // 确保DevTools开启
    },
  });

  // 输出 preload 路径以便调试（确保 preload 文件在运行时可用）
  try {
    const preloadPath = path.join(__dirname, 'preload.js');
    console.log('预加载脚本预期路径:', preloadPath);
    console.log('预加载脚本是否存在:', fs.existsSync(preloadPath));
  } catch (err) {
    console.error('检查 preload 路径时出错:', err);
  }
  
  // 页面加载完成的简单日志 — 所有渲染可用 API 已通过 preload.js 暴露
  global.mainWindow.webContents.on('did-finish-load', () => {
    console.log('页面加载完成 — 使用 preload 暴露的 electronAPI');
  });
  
  // 自动打开DevTools
  global.mainWindow.webContents.openDevTools();
  console.log('DevTools已打开');

  // 在开发模式下加载Vite服务器的URL
  // 在生产模式下加载打包后的HTML文件
  if (global.mainWindow) {
    // 使用process.argv来判断是否是开发模式，更加可靠
    const isDev = process.argv.includes('--dev');
    if (isDev) {
      global.mainWindow.loadURL('http://localhost:5173');
      // 开发模式下打开开发者工具
      global.mainWindow.webContents.openDevTools();
    } else {
      global.mainWindow.loadFile(path.join(__dirname, '../../dist/index.html'));
    }

    // 当窗口关闭时
    global.mainWindow.on('closed', () => {
      global.mainWindow = null;
    });
  }
}

// 当Electron完成初始化后创建窗口
app.whenReady().then(() => {
  createWindow();

  // 在macOS上，当点击dock图标并且没有其他窗口打开时，重新创建一个窗口
  app.on('activate', () => {
    if (require('electron').BrowserWindow.getAllWindows().length === 0) createWindow();
  });
});

// 当所有窗口关闭时退出应用（Windows和Linux）
app.on('window-all-closed', () => {
  if (process.platform !== 'darwin') {
    app.quit();
  }
});

// 设置IPC通信处理器
// 处理获取串口列表请求
ipcMain.handle('list-serial-ports', async () => {
  try {
    console.log('正在获取可用串口列表...');
    const ports = await SerialPort.list();
    console.log('发现串口:', ports.map((p: any) => p.path));
    return ports.map((p: any) => ({
      path: p.path,
      manufacturer: p.manufacturer || '未知',
      serialNumber: p.serialNumber || '',
      pnpId: p.pnpId || '',
      locationId: p.locationId || '',
      vendorId: p.vendorId || '',
      productId: p.productId || ''
    }));
  } catch (error) {
    console.error('获取串口列表失败:', error);
    return [];
  }
});

// 处理打开串口请求
ipcMain.handle('open-serial-port', async (_event, params: { port: string, baudRate: number }) => {
  try {
    const { port: portPath, baudRate } = params;
    console.log(`尝试打开串口: ${portPath}, 波特率: ${baudRate}`);
    
    // 如果已打开串口，先关闭
    if (port && port.isOpen) {
      await port.close();
      port = null;
      parser = null;
    }
    
    // 修复SerialPort构造函数参数
      port = new SerialPort({
        path: portPath,
        baudRate: parseInt(baudRate.toString()),
        autoOpen: false
      });
    
    // 设置Readline解析器
    parser = port.pipe(new ReadlineParser({ delimiter: '\n' }));
    
    // 打开串口
    await new Promise<void>((resolve, reject) => {
      port.open((err: Error | null) => {
        if (err) {
          reject(err);
        } else {
          resolve();
        }
      });
    });
    
    console.log(`串口 ${portPath} 已成功打开`);
    
    // 监听数据事件
    parser.on('data', (data: string) => {
      console.log(`收到串口数据: ${data}`);
      // 通过IPC发送数据到渲染进程
      global.mainWindow?.webContents.send('serial-data', data);
    });
    
    // 监听错误事件
    port.on('error', (error: Error) => {
      console.error('串口错误:', error);
      global.mainWindow?.webContents.send('serial-error', error.message);
    });
    
    return { success: true, message: `串口 ${portPath} 已成功打开` };
  } catch (error: any) {
    console.error('打开串口失败:', error);
    return { success: false, error: error.message };
  }
});

// 处理关闭串口请求
ipcMain.handle('close-serial-port', async () => {
  try {
    if (port && port.isOpen) {
      await port.close();
      port = null;
      parser = null;
      console.log('串口已成功关闭');
      return { success: true, message: '串口已成功关闭' };
    } else {
      return { success: true, message: '串口未打开' };
    }
  } catch (error: any) {
    console.error('关闭串口失败:', error);
    return { success: false, error: error.message };
  }
});

// 处理发送数据请求
ipcMain.handle('send-data', async (_event, params: { data: string }) => {
  try {
    if (!port || !port.isOpen) {
      throw new Error('串口未打开');
    }
    
    const { data } = params;
    console.log(`发送数据: ${data}`);
    await new Promise<void>((resolve, reject) => {
      port.write(data, (err: Error | null) => {
        if (err) {
          reject(err);
        } else {
          resolve();
        }
      });
    });
    
    return { success: true, message: '数据发送成功' };
  } catch (error: any) {
    console.error('发送数据失败:', error);
    return { success: false, error: error.message };
  }
});

// 处理内部API调用
ipcMain.handle('electron-api-call', async (_event, message) => {
  try {
    console.log('收到electron-api-call:', message);
    const channel = message.channel;
    const requestId = message.requestId;
    const args = message.args || [];
    
    // 直接调用对应的处理逻辑，不使用不存在的handleSync
    if (channel === 'list-serial-ports') {
      // 直接获取串口列表
      const ports = await SerialPort.list();
      const result = ports.map((p: any) => ({
        path: p.path,
        manufacturer: p.manufacturer || '未知',
        serialNumber: p.serialNumber || '',
        pnpId: p.pnpId || '',
        locationId: p.locationId || '',
        vendorId: p.vendorId || '',
        productId: p.productId || ''
      }));
      return { requestId, result };
    } else if (channel === 'open-serial-port' && args.length > 0) {
      // 直接打开串口
      const params = args[0];
      const portPath = params.port || params.portPath;
      const baudRate = params.baudRate;
      
      if (!portPath || !baudRate) {
        return { requestId, result: { success: false, error: '缺少必要参数' } };
      }
      
      // 实现打开串口逻辑
      try {
        // 如果已打开串口，先关闭
        if (port && port.isOpen) {
          await port.close();
          port = null;
          parser = null;
        }
        
        port = new SerialPort({
          path: portPath,
          baudRate: parseInt(baudRate.toString()),
          autoOpen: false
        });
        
        // 设置Readline解析器
        parser = port.pipe(new ReadlineParser({ delimiter: '\n' }));
        
        // 打开串口
        await new Promise<void>((resolve, reject) => {
          port.open((err: Error | null) => {
            if (err) {
              reject(err);
            } else {
              resolve();
            }
          });
        });
        
        // 监听数据事件
        parser.on('data', (data: string) => {
          if (global.mainWindow) {
            global.mainWindow.webContents.send('serial-data', data);
          }
        });
        
        // 监听错误事件
        port.on('error', (error: Error) => {
          if (global.mainWindow) {
            global.mainWindow.webContents.send('serial-error', error.message);
          }
        });
        
        return { requestId, result: { success: true, message: '串口已成功打开' } };
      } catch (error: any) {
        return { requestId, result: { success: false, error: error.message } };
      }
    } else if (channel === 'close-serial-port') {
      // 直接关闭串口
      try {
        if (port && port.isOpen) {
          await port.close();
          port = null;
          parser = null;
          return { requestId, result: { success: true, message: '串口已成功关闭' } };
        } else {
          return { requestId, result: { success: true, message: '串口未打开' } };
        }
      } catch (error: any) {
        return { requestId, result: { success: false, error: error.message } };
      }
    } else if (channel === 'send-data' && args.length > 0) {
      // 直接发送数据
      try {
        if (!port || !port.isOpen) {
          return { requestId, result: { success: false, error: '串口未打开' } };
        }
        
        const params = args[0];
        const data = params.data || params;
        
        await new Promise<void>((resolve, reject) => {
          port.write(data, (err: Error | null) => {
            if (err) {
              reject(err);
            } else {
              resolve();
            }
          });
        });
        
        return { requestId, result: { success: true, message: '数据发送成功' } };
      } catch (error: any) {
        return { requestId, result: { success: false, error: error.message } };
      }
    }
    
    return { requestId, result: { success: false, error: '未知的通道' } };
  } catch (error: any) {
    console.error('处理electron-api-call失败:', error);
    return { requestId: message?.requestId || '', result: { success: false, error: error.message } };
  }
});

// 添加空导出使文件成为一个模块，解决global声明问题
export {};